home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / telecomm / sticpsrc.lzh / SOURCE.ARC / SESSION.C < prev    next >
C/C++ Source or Header  |  1990-08-12  |  10KB  |  461 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "config.h"
  4. #include "global.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "ftp.h"
  12. #include "telnet.h"
  13. #include "finger.h"
  14. #ifdef    SCREEN
  15. #include "screen.h"
  16. #endif
  17. #include "session.h"
  18. #include "cmdparse.h"
  19.  
  20. struct session *sessions;
  21. struct session *current;
  22.  
  23. char notval[] = "Not a valid control block\n";
  24.  
  25. static char badsess[] = "Invalid session\n";
  26. static char nocurr[] = "No current session\n";
  27. static char noupload[] = "Uploading on %s channel not supported\n";
  28.  
  29. /* Convert a character string containing a decimal session index number
  30.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  31.  * If the index is out of range or unused, return NULLSESSION.
  32.  */
  33. static struct session *
  34. sessptr(cp)
  35. char *cp;
  36. {
  37.     register struct session *s;
  38.     unsigned int i;
  39.  
  40.     if(cp == NULLCHAR){
  41.         s = current;
  42.     } else {
  43.         if((i = atoi(cp)) >= nsessions)
  44.             return NULLSESSION;
  45.         s = &sessions[i];
  46.     }
  47.     if(s == NULLSESSION || s->type == FREE)
  48.         return NULLSESSION;
  49.  
  50.     return s;
  51. }
  52.  
  53. /* Select and display sessions */
  54. dosession(argc,argv)
  55. int argc;
  56. char *argv[];
  57. {
  58.     struct session *s;
  59.     extern char *tcpstates[];
  60.     extern char *ax25states[];
  61.     char *tcp_port();
  62.  
  63.     if(argc > 1){
  64. #ifdef    SCREEN
  65.         current->win->active = 0;
  66. #endif
  67.         if((current = sessptr(argv[1])) != NULLSESSION){
  68. #ifdef    SCREEN
  69.             current->win->active = 1;
  70. #endif
  71.             go();
  72.         }
  73.         return 0;
  74.     }
  75.     printf(" #       &CB Type   Rcv-Q  Snd-Q  State        Remote socket\n");
  76.     for(s=sessions; s < &sessions[nsessions];s++){
  77.         switch(s->type){
  78. #ifdef    IP
  79.         case TELNET:
  80.             printf("%c%-3ld%8lx Telnet  %4d   %4d  %-13s%-s:%s",
  81.              (current == s)? '*':' ',
  82.              (long)(s - sessions),
  83.              ptr2long(s->cb.telnet->tcb),
  84.              s->cb.telnet->tcb->rcvcnt,
  85.              s->cb.telnet->tcb->sndcnt,
  86.              tcpstates[s->cb.telnet->tcb->state],
  87.              s->name,
  88.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  89.             break;
  90. #ifdef    FTPC
  91.         case FTP:
  92.             printf("%c%-3ld%8lx FTP     %4d   %4d  %-13s%-s:%s",
  93.              (current == s)? '*':' ',
  94.              (long)(s - sessions),
  95.              ptr2long(s->cb.ftp->control),
  96.              s->cb.ftp->control->rcvcnt,
  97.              s->cb.ftp->control->sndcnt,
  98.              tcpstates[s->cb.ftp->control->state],
  99.              s->name,
  100.              tcp_port(s->cb.ftp->control->conn.remote.port));
  101.             break;
  102. #endif
  103. #endif
  104. #ifdef    AX25
  105.         case AX25TNC:
  106.             printf("%c%-3ld%8lx AX25    %4d   %4d  %-13s%-s",
  107.              (current == s)? '*':' ',
  108.              (long)(s - sessions),
  109.              ptr2long(s->cb.ax25_cb),
  110.              len_mbuf(s->cb.ax25_cb->rxq),
  111.              len_q(s->cb.ax25_cb->txq),
  112.              ax25states[s->cb.ax25_cb->state],
  113.              s->name);
  114.             break;
  115. #endif
  116. #ifdef    IP
  117.         case FINGER:
  118.             printf("%c%-3ld%8lx Finger  %4d   %4d  %-13s%-s:%s",
  119.              (current == s)? '*':' ',
  120.              (long)(s - sessions),
  121.              ptr2long(s->cb.finger->tcb),
  122.              s->cb.finger->tcb->rcvcnt,
  123.              s->cb.finger->tcb->sndcnt,
  124.              tcpstates[s->cb.finger->tcb->state],
  125.              s->name,
  126.              tcp_port(s->cb.finger->tcb->conn.remote.port));
  127.             break;
  128. #endif
  129.         default:
  130.             continue;
  131.         }
  132.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  133.             printf("\t");
  134.         if(s->rfile != NULLCHAR)
  135.             printf("Record: %s ",s->rfile);
  136.         if(s->ufile != NULLCHAR)
  137.             printf("Upload: %s",s->ufile);
  138.         printf("\n");
  139.     }
  140.     return 0;
  141. }
  142. /* Enter conversational mode with current session */
  143. int
  144. go()
  145. {
  146.     void rcv_char(),ftpccr(),ax_rx();
  147.  
  148.     if(current == NULLSESSION || current->type == FREE)
  149.         return 0;
  150.     mode = CONV_MODE;
  151. #ifdef    SCREEN
  152.     Activate(current->win);
  153. #endif
  154.     switch(current->type){
  155. #ifdef    IP
  156.     case TELNET:
  157.         if(current->cb.telnet->remote[TN_ECHO])
  158.             raw();    /* Re-establish raw mode if it was set */
  159.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  160.         break;
  161. #ifdef FTPC
  162.     case FTP:
  163.         ftpccr(current->cb.ftp->control,0);
  164.         break;
  165. #endif
  166. #endif
  167. #ifdef    AX25
  168.     case AX25TNC:
  169.         ax_rx(current->cb.ax25_cb,0);
  170.         break;
  171. #endif
  172. #ifdef    IP
  173.     case FINGER:
  174.         fingcli_rcv(current->cb.finger->tcb,0);
  175.         break;
  176. #endif
  177.     }
  178.     return 0;
  179. }
  180. doclose(argc,argv)
  181. int argc;
  182. char *argv[];
  183. {
  184.     struct session *s;
  185.  
  186.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  187.         printf(badsess);
  188.         return -1;
  189.     }
  190.     switch(s->type){
  191. #ifdef    IP
  192.     case TELNET:
  193.         close_tcp(s->cb.telnet->tcb);
  194.         break;
  195. #ifdef FTPC
  196.     case FTP:
  197.         close_tcp(s->cb.ftp->control);
  198.         break;
  199. #endif
  200. #endif
  201. #ifdef    AX25
  202.     case AX25TNC:
  203.         if (argv[0][0] == 'c')
  204.             close_ax25(s->cb.ax25_cb);
  205.         else
  206.             disc_ax25(s->cb.ax25_cb);
  207.         break;
  208. #endif
  209. #ifdef    IP
  210.     case FINGER:
  211.         close_tcp(s->cb.finger->tcb);
  212.         break;
  213. #endif
  214.     }
  215.     return 0;
  216. }
  217. doreset(argc,argv)
  218. int argc;
  219. char *argv[];
  220. {
  221.     struct session *s;
  222.  
  223.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  224.         printf(badsess);
  225.         return -1;
  226.     }
  227.     switch(s->type){
  228. #ifdef    IP
  229.     case TELNET:
  230.         reset_tcp(s->cb.telnet->tcb);
  231.         break;
  232. #ifdef    FTPC
  233.     case FTP:
  234.         if(s->cb.ftp->data != NULLTCB){
  235.             reset_tcp(s->cb.ftp->data);
  236.             s->cb.ftp->data = NULLTCB;
  237.         }
  238.         reset_tcp(s->cb.ftp->control);
  239.         break;
  240. #endif
  241. #endif
  242. #ifdef    AX25
  243.     case AX25TNC:
  244.         reset_ax25(s->cb.ax25_cb);
  245.         break;
  246. #endif
  247. #ifdef    IP
  248.     case FINGER:
  249.         reset_tcp(s->cb.finger->tcb);
  250.         break;
  251. #endif
  252.     }
  253.     return 0;
  254. }
  255. int
  256. dokick(argc,argv)
  257. int argc;
  258. char *argv[];
  259. {
  260.     void tcp_timeout();
  261.     struct session *s;
  262.  
  263.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  264.         printf(badsess);
  265.         return -1;
  266.     }
  267.     switch(s->type){
  268. #ifdef    IP
  269.     case TELNET:
  270.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  271.             printf(notval);
  272.             return 1;
  273.         }
  274.         break;
  275. #ifdef    FTPC
  276.     case FTP:
  277.         if(kick_tcp(s->cb.ftp->control) == -1){
  278.             printf(notval);
  279.             return 1;
  280.         }
  281.         if(s->cb.ftp->data != NULLTCB)
  282.             kick_tcp(s->cb.ftp->data);
  283.         break;
  284. #endif
  285. #endif
  286. #ifdef    AX25
  287.     case AX25TNC:
  288.         if(kick_ax25(s->cb.ax25_cb) == -1){
  289.             printf(notval);
  290.             return 1;
  291.         }
  292.         break;
  293. #ifdef    IP
  294.     case FINGER:
  295.         if(kick_tcp(s->cb.finger->tcb) == -1){
  296.             printf(notval);
  297.             return 1;
  298.         }
  299.         break;
  300. #endif
  301.     default:
  302.         return 1;
  303. #endif
  304.     }
  305.     return 0;
  306. }
  307. struct session *
  308. newsession()
  309. {
  310.     register int i;
  311.  
  312.     for(i=0;i<nsessions;i++)
  313.         if(sessions[i].type == FREE){
  314. #ifdef    SCREEN
  315.             struct win *makewindow();
  316.  
  317.             if ((sessions[i].win = makewindow()) == NULL)
  318.                 return NULLSESSION;
  319.  
  320.             sessions[i].win->active = 1;
  321. #endif
  322.             return &sessions[i];
  323.     }
  324.     return NULLSESSION;
  325. }
  326. freesession(s)
  327. struct session *s;
  328. {
  329.     if(s == NULLSESSION || s < sessions || s >= &sessions[nsessions])
  330.         return;
  331.     if(s->record != NULLFILE){
  332.         fclose(s->record);
  333.         s->record = NULLFILE;
  334.     }
  335.     if(s->rfile != NULLCHAR){
  336.         free(s->rfile);
  337.         s->rfile = NULLCHAR;
  338.     }
  339.     if(s->upload != NULLFILE){
  340.         fclose(s->upload);
  341.         s->upload = NULLFILE;
  342.     }
  343.     if(s->ufile != NULLCHAR){
  344.         free(s->ufile);
  345.         s->ufile = NULLCHAR;
  346.     }
  347.     if(s->name != NULLCHAR){
  348.         free(s->name);
  349.         s->name = NULLCHAR;
  350.     }
  351. #ifdef    SCREEN
  352.     freewindow(s->win);
  353. #endif
  354.     s->type = FREE;
  355. }
  356. /* Control session recording */
  357. dorecord(argc,argv)
  358. int argc;
  359. char *argv[];
  360. {
  361.     if(current == NULLSESSION || current->type == FREE){
  362.         printf(nocurr);
  363.         return 1;
  364.     }
  365.     if(argc > 1){
  366.         if(current->rfile != NULLCHAR){
  367.             fclose(current->record);
  368.             free(current->rfile);
  369.             current->record = NULLFILE;
  370.             current->rfile = NULLCHAR;
  371.         }
  372.         /* Open new record file, unless file name is "off" or "stop",
  373.          * which means disable recording
  374.          */
  375.         if(strcmp(argv[1],"off") != 0 && strcmp(argv[1],"stop") != 0
  376.          && (current->record = fopen(argv[1],binmode[APPEND_BINARY])) != NULLFILE){
  377.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  378.             strcpy(current->rfile,argv[1]);
  379.         }
  380.     }
  381.     if(current->rfile != NULLCHAR)
  382.         printf("Recording into %s\n",current->rfile);
  383.     else
  384.         printf("Recording off\n");
  385.     return 0;
  386. }
  387. /* Control file transmission */
  388. doupload(argc,argv)
  389. int argc;
  390. char *argv[];
  391. {
  392.     struct tcb *tcb;
  393.     struct ax25_cb *axp;
  394.     int16 window;
  395.  
  396.     if(current == NULLSESSION || current->type == FREE){
  397.         printf(nocurr);
  398.         return 1;
  399.     }
  400.     if(argc > 1){
  401.         switch(current->type){
  402. #ifdef    IP
  403.         cas